package com.koron.system.orgSort.service.impl;


import com.koron.bean.system.org.OrgBean;
import com.koron.bean.system.org.query.OrgQuery;
import com.koron.system.org.service.OrgService;
import com.koron.system.orgSort.bean.po.AppOrgSort;
import com.koron.system.orgSort.dao.AppOrgSortDao;
import com.koron.system.orgSort.service.AppOrgSortService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

import java.time.LocalDate;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

/**
 * 组织顺序表(AppOrgSort)表服务实现类
 *
 * @author jzp
 * @since 2022-08-25 10:37:20
 */
@Slf4j
@Service
public class AppOrgSortServiceImpl implements AppOrgSortService {
    @Autowired
    private AppOrgSortDao appOrgSortDao;

    @Autowired
    OrgService orgService;

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    /**
     * 通过ID查询单条数据
     *
     * @param id 主键
     * @return 实例对象
     */
    @Override
    public AppOrgSort getById(String id) {
        return appOrgSortDao.selectById(id);
    }

    /**
     * 查询所有数据
     *
     * @return 对象列表
     */
    @Override
    public List<AppOrgSort> list(AppOrgSort appOrgSort) {
        return appOrgSortDao.selectList(appOrgSort);
    }

    /**
     * 新增数据
     *
     * @param appOrgSort 实例对象
     * @return 是否成功
     */
    @Override
    public boolean save(AppOrgSort appOrgSort) {
        return appOrgSortDao.insert(appOrgSort) > 0;
    }

    /**
     * 修改数据
     *
     * @param appOrgSort 实例对象
     * @return 是否成功
     */
    @Override
    public boolean update(AppOrgSort appOrgSort) {
        return appOrgSortDao.update(appOrgSort) > 0;
    }

    @Override
    @Scheduled(cron = "0 0 3 * * ?")
    public void sync() {
        log.info("同步组织顺序表");
        Boolean result = stringRedisTemplate.opsForValue().setIfAbsent("syncOrg", LocalDate.now().toString(), 10, TimeUnit.SECONDS);
        // 如果设置成功
        if (Boolean.TRUE.equals(result)) {
            try {
                // 1. 查询整个组织表的数据
                List<OrgBean> orgBeans = orgService.queryNextOrgList(new OrgQuery());
                List<OrgBean> orgBeansBeforeSort = deptSortByTreeLevel(orgBeans, "1");
                List<AppOrgSort> collect = IntStream.range(0, orgBeansBeforeSort.size()).mapToObj(i -> {
                    OrgBean orgBean = orgBeansBeforeSort.get(i);
                    AppOrgSort appOrgSort = new AppOrgSort();
                    appOrgSort.setOrgId(orgBean.getId());
                    appOrgSort.setName(orgBean.getName());
                    appOrgSort.setAppid(orgBean.getAppid());
                    appOrgSort.setParent(orgBean.getParent());
                    appOrgSort.setLevel(orgBean.getLevel());
                    appOrgSort.setLevelPath(orgBean.getLevelPath());
                    appOrgSort.setSort(i);
                    return appOrgSort;
                }).collect(Collectors.toList());

                // 2. 清空原表数据
                appOrgSortDao.truncateTable();

                // 3. 批量插入
                appOrgSortDao.insertBatch(collect);
            } finally {
                stringRedisTemplate.delete("syncOrg");
            }
        }

    }

    /**
     * 通过主键删除数据
     *
     * @param id 主键
     * @return 是否成功
     */
    @Override
    public boolean deleteById(String id) {
        return appOrgSortDao.hidden(id) > 0;
    }

    /**
     * 部门 根据树排序
     */
    private List<OrgBean> deptSortByTreeLevel(List<OrgBean> source, String rootLevel) {
        // 最终结果，先存顶级节点
        List<OrgBean> result = source.stream().filter(e -> rootLevel.equals(e.getLevel())).collect(Collectors.toList());
        // 从第下一层开始
        int initLevel = Integer.parseInt(rootLevel);
        // 筛选每一层的数据
        while (true) {
            int finalInitLevel = initLevel;
            List<OrgBean> collect = source.stream().filter(e -> String.valueOf(finalInitLevel).equals(e.getLevel())).collect(Collectors.toList());
            if (collect.size() == 0) {
                break;
            }
            for (int i = 0; i < result.size(); i++) {
                OrgBean orgBean = result.get(i);
                // 从result中找父级节点
                if (String.valueOf(initLevel-1).equals(orgBean.getLevel())){
                    List<OrgBean> child = collect.stream().filter(e -> orgBean.getId().equals(e.getParent())).collect(Collectors.toList());
                    result.addAll(i+1, child);
                    i += child.size();
                }
            }
            initLevel += 1;
        }
        return result;
    }
}
